import store from '@/store'
// 公用函数
const fns = {

    // 由path获取name，自动简化
    // 如'/platform/foo/edit'转为'platform_foo_edit'
    getNameByPath(path) {
        if (path) {
            path = this.simplifyPath(path);
            path = path.substring(1);
            return _.replace(path, /\//g, '_');
        }
    },

    //生成随机guid
    createGuid() {
        function S4() {
           return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
        }
        return (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4());
    },

    // 由name获取path，自动简化
    // 如'platform_foo_edit'转为'/platform/foo/edit'
    getPathByName(name) {
        if (name) {
            name = this.simplifyName(name);
            name = '_' + name;
            return _.replace(name, /_/g, '/');
        }
    },

    // 去除name中的查询条件，以'=vae='为标识
    // 去除name中的动作标识，以'@'为标识
    simplifyName(name) {
        if (name) {
            let i1 = name.indexOf('=vae=');
            if (i1 > 0) {
                name = name.substring(0, i1);
                let i2 = name.lastIndexOf('_');
                if (i2 > 0) {
                    name = name.substring(0, i2);
                }
            }
            let i3 = name.indexOf('@');
            if (i3 > 0) {
                name = name.substring(i3 + 1);
            }
            return name;
        }
    },

    // 去除path中的查询条件，以'?'为标识
    // 去除path中的动作标识，以'/@'为标识
    // 去除末尾的'/index'
    simplifyPath(path) {
        if (path) {
            let index = path.indexOf('?');
            if (index > 0) {
                path = path.substring(0, index);
            }
            if (_.endsWith(path, '/index')) {
                path = path.substring(0, path.length - 6);
            }
            if (_.startsWith(path, '/@')) {
                path = path.substring(_.indexOf(path, '/', 2));
            }
            return path;
        }
    },

    // 由name获取文件路径，从@/modules/后开始
    // 如'platform_foo_edit'转为'platform/views/foo.edit'
    getFilePathByName(name) {
        if (name) {
            let i = name.indexOf('_');
            if (i > 0) {
                let m = name.substring(0, i);
                let p = name.substring(i + 1);
                let n = _.replace(p, /_/g, '.');
                return m + '/views/' + n;
            }
        }
    },

    // 生成query字符串，以=vae=作为标识
    // 如{foo:1,bar:2}转为'index_foo=1&bar=2'
    getQueryString(query) {
        let result = "";
        if (query) {
            Object.keys(query).forEach(key => {
                if (query[key]) {
                    result += key + '=';
                    result += query[key];
                    result += '&';
                }
            });
            if (_.endsWith(result, '&')) {
                result = result.substring(0, result.length - 1);
            }
            if (result.length > 0) {
                result = '=vae=' + result;
            }
        }
        return result;
    },

    // 由url获取path
    // 如'/system/foo/edit/index?id=1'转为'/system/foo/edit'
    getPathByUrl(url) {
        let i = url.indexOf('?');
        if (i >= 0) {
            url = url.substring(0, i);
        }
        if (_.endsWith(url, '/index')) {
            url = url.substring(0, url.indexOf('/index'));
        }
        if (url) {
            return url;
        }
    },

    // 由path获取action，以'@'为标识
    // 如'/@ws/system/foo'转为'ws'
    getActionByPath(path) {
        if (path && _.startsWith(path, '/@')) {
            return path.substring(2, _.indexOf(path, '/', 2));
        }
    },

    // 递归树形结构，获取ID对应的节点
    getTreeNodeById(tree, id) {
        return this.getTreeNode(tree, e => e.id == id);
    },

    // 递归树形结构，获取全路径对应的节点
    getTreeNodeByFullpath(tree, fullPath) {
        return this.getChildrenInTreeByFullpath(tree,fullPath);
    },

    // 递归树形结构，匹配全路径对应的节点
    getChildrenInTreeByFullpath(tree_data,fullPath) {
        var hasFound = false, // 表示是否有找到id值
          result = null;
        var fn = function (tree_data) {
          if (Array.isArray(tree_data) && !hasFound) { // 判断是否是数组并且没有的情况下，
            tree_data.forEach(item => {
               if (item.fullPath === fullPath.replace('/index', '')) { // 数据循环每个子项，并且判断子项下边是否有全路径值
                result = item; // 返回的结果等于每一项
                hasFound = true; // 并且找到id值
              } else if (item.children) {
                fn(item.children); // 递归调用下边的子项
              }
            })
          }
        }
        fn(tree_data); // 调用一下
        return result;
    },

    // 递归树形结构，根据首个断言为真的节点
    getTreeNode(tree, assert) {
        function recurTree(src = [], assert, result) {
            src.forEach(e => {
                if (assert && typeof(assert) === 'function' && !result) {
                    if (assert(e)) {
                        result = e;
                    } else if (e.children && Array.isArray(e.children)) {
                        result = recurTree(e.children, assert, result) || result;
                    }
                }
            });
            return result;
        }
        return recurTree(tree, assert);
    },

    //递归树形结构，根据id查找节点数据
    getChildrenInTreeById(tree_data,id) {
        var hasFound = false, // 表示是否有找到id值
          result = null;
        var fn = function (tree_data) {
          if (Array.isArray(tree_data) && !hasFound) { // 判断是否是数组并且没有的情况下，
            tree_data.forEach(item => {
               if (item.id === id) { // 数据循环每个子项，并且判断子项下边是否有id值
                result = item; // 返回的结果等于每一项
                hasFound = true; // 并且找到id值
              } else if (item.children) {
                fn(item.children); // 递归调用下边的子项
              }
            })
          }
        }
        fn(tree_data); // 调用一下
        return result;
    },

    //递归树形结构，根据value查找节点数据
    getChildrenInTreeByValue(tree_data,value) {
        var hasFound = false, // 表示是否有找到id值
          result = null;
        var fn = function (tree_data) {
          if (Array.isArray(tree_data) && !hasFound) { // 判断是否是数组并且没有的情况下，
            tree_data.forEach(item => {
               if (item.value === value) { // 数据循环每个子项，并且判断子项下边是否有id值
                result = item; // 返回的结果等于每一项
                hasFound = true; // 并且找到id值
              } else if (item.children) {
                fn(item.children); // 递归调用下边的子项
              }
            })
          }
        }
        fn(tree_data); // 调用一下
        return result;
    },
	//树转数组
	getArrByTree(tree) {
		const result = [];
		tree.forEach(item => {
			const loop = data => {
				result.push(data);
				let child = data.children
				if (child) {
					for (let i = 0; i < child.length; i++) {
						loop(child[i])
					}
				}
			}
			loop(item);
		})
		return result;
	},
	//通过字典名称，字典编码、字典值来获取对应的名称，如果没有找到返回false
	getDictValByNameCodeAndVal(name,code,val){
	  let dict = store.state.app.dict[name] || Vae.getDicTree(name);
	  let str = code+val;
	  let temp = _.find(dict, function(o) { return o.code == str; });
	  if(temp){
	    return temp.data.v_shortname
	  }else{
	    return '--';
	  }
	},

}

export default fns